/**
 * Vue Handler
 * Vue.js 框架特殊对象处理器
 */

(function () {
    'use strict';

    // 确保 LanguageHandlers 已加载
    if (typeof window.LanguageHandlers === 'undefined') {
        console.warn('LanguageHandlers not found, please load language-handlers.js first');
        return;
    }

    const VueHandler = {
        name: 'vue',
        
        /**
         * 判断是否为 Vue 特殊对象
         * @param {*} obj - 要检查的对象
         * @returns {boolean} 是否为 Vue 特殊对象
         */
        isSpecialObject(obj) {
            if (!obj || typeof obj !== 'object') return false;
            
            // 检查 Vue 2 组件特征
            if (obj.$el !== undefined || obj.$options !== undefined || obj.$parent !== undefined) {
                return true;
            }
            
            // 检查 Vue 3 组件特征
            if (obj.__v_isVue !== undefined || obj.__v_isRef !== undefined) {
                return true;
            }
            
            // 检查 Vue 3 的其他组件特征
            if (obj.__v_skip !== undefined) {
                return true;
            }
            
            // 检查 Vue 3 响应式数据对象特征
            if (obj.__v_isReactive !== undefined || 
                obj.__v_isReadonly !== undefined || 
                obj.__v_isShallow !== undefined ||
                obj.__v_isComputed !== undefined ||
                obj.__v_isEffect !== undefined ||
                obj.__v_isWatch !== undefined) {
                return true;
            }
            
            // 检查构造函数名称
            if (obj.constructor && (
                obj.constructor.name === 'VueComponent' ||
                obj.constructor.name.includes('Vue') ||
                obj.constructor.name.includes('Component')
            )) {
                return true;
            }
            
            // 检查是否有 Vue 组件特有的属性
            const vueComponentProps = ['$vnode', '$attrs', '$listeners', '$scopedSlots', '$slots', '$el', '$options', '$parent'];
            return vueComponentProps.some(prop => Object.prototype.hasOwnProperty.call(obj, prop));
        },

        /**
         * 判断是否应该过滤对象
         * @param {*} obj - 要检查的对象
         * @returns {boolean} 是否应该过滤
         */
        shouldFilter(obj) {
            // Vue 组件实例应该被过滤
            if (obj.$el !== undefined || obj.$options !== undefined || obj.$parent !== undefined) {
                return true;
            }
            
            if (obj.__v_isVue !== undefined) {
                return true;
            }
            
            if (obj.__v_skip !== undefined) {
                return true;
            }
            
            // 检查构造函数名称 - 组件应该被过滤
            if (obj.constructor && (
                obj.constructor.name === 'VueComponent' ||
                (obj.constructor.name.includes('Vue') && 
                 !obj.constructor.name.includes('Ref') && 
                 !obj.constructor.name.includes('Reactive') &&
                 !obj.constructor.name.includes('Computed') &&
                 !obj.constructor.name.includes('Effect') &&
                 !obj.constructor.name.includes('Watch')) ||
                obj.constructor.name.includes('Component')
            )) {
                return true;
            }
            
            // 检查是否有 Vue 组件特有的属性
            const vueComponentProps = ['$vnode', '$attrs', '$listeners', '$scopedSlots', '$slots', '$el', '$options', '$parent'];
            return vueComponentProps.some(prop => Object.prototype.hasOwnProperty.call(obj, prop));
        },

        /**
         * 获取过滤消息
         * @param {*} obj - 被过滤的对象
         * @returns {string} 过滤消息
         */
        getFilterMessage(obj) {
            return '[Vue Component]';
        },

        /**
         * 提取 Vue 对象的实际值
         * @param {*} obj - Vue 对象
         * @param {number} depth - 当前深度
         * @param {WeakSet} visited - 已访问的对象集合
         * @param {Object} utils - 工具函数集合
         * @returns {*} 提取的值
         */
        extractValue(obj, depth, visited, utils) {
            try {
                // 对于 ref 对象，提取 .value 属性
                if (obj.__v_isRef !== undefined && obj.value !== undefined) {
                    return utils.finalCircularCleanup(obj.value, depth - 1, visited);
                }
                
                // 对于 computed 对象，提取 .value 属性
                if (obj.__v_isComputed !== undefined && obj.value !== undefined) {
                    return utils.finalCircularCleanup(obj.value, depth - 1, visited);
                }
                
                // 对于其他响应式对象（reactive, readonly, shallow 等），直接处理对象本身
                // 但排除内部 Vue 属性
                const cleaned = {};
                const keys = Object.keys(obj);
                for (const key of keys) {
                    // 跳过 Vue 内部属性
                    if (key.startsWith('__v_') || key.startsWith('_')) {
                        continue;
                    }
                    
                    try {
                        const value = obj[key];
                        cleaned[key] = utils.finalCircularCleanup(value, depth - 1, visited);
                    } catch (e) {
                        cleaned[key] = '[Inaccessible]';
                    }
                }
                return cleaned;
            } catch (e) {
                return '[Vue Data - Inaccessible]';
            }
        }
    };

    // 注册 Vue 处理器
    window.LanguageHandlers.register('vue', VueHandler);

})();
